package com.sob.bountyhunter;

import java.util.ArrayList;
import java.util.Collections;

import org.newdawn.slick.GameContainer;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.tiled.TiledMap;
import org.newdawn.slick.util.pathfinding.PathFindingContext;
import org.newdawn.slick.util.pathfinding.TileBasedMap;

import com.sob.bountyhunter.entidades.ComparadorZ;
import com.sob.bountyhunter.entidades.Entidad;

public class Mapa implements TileBasedMap {
	public static final int TILE_SIZE = 32;
	public static final int TILESET_WIDTH = 10;
	
	//private int [][]mapa;
	
	//private Image tileSetImg;
	//private SpriteSheet tileSetSheet;
	private int width, height;
	
	public TiledMap map;
	private boolean [][]bloqueado;
	public ArrayList<Entidad> entidades = new ArrayList<Entidad>();
	
	/*
	public Mapa(int w, int h, String tsFile) throws SlickException
	{
		width=w;
		height=h;
		
		tileSetImg=new Image(tsFile);
		//tileSetSheet=new SpriteSheet(tileSetImg, TILE_SIZE, TILE_SIZE);
		
		mapa=new int[width][height];
		
		generaPrueba();
	}*/
	
	public Mapa(String mapFile) throws SlickException{
		map=new TiledMap(mapFile);
		width=map.getWidth();
		height=map.getHeight();
		
		bloqueado=new boolean[map.getWidth()][map.getHeight()];
		
		for(int x=0;x<map.getWidth();x++){
			for(int y=0;y<map.getHeight();y++){
				int id=map.getTileId(x, y, 0);
				bloqueado[x][y]=map.getTileProperty(id, "bloqueado", "true").equals("true");				
			}
		}
	}
	
	public void addEntidad(Entidad e)
	{
		if(!entidades.contains(e)){
			entidades.add(e);
		}
	}
	
	public boolean delEntidad(Entidad e)
	{
		return entidades.remove(e);
	}
	
	public boolean isBlocked(int x, int y)
	{
		boolean res=bloqueado[x][y];
		return res;
	}

	public boolean isBlocked(float x, float y)
	{
		int tx=(int)x/TILE_SIZE;
		int ty=(int)y/TILE_SIZE;
		
		boolean res;
		
		try{
			res=bloqueado[tx][ty];
		}catch(ArrayIndexOutOfBoundsException e){
			res=true;
		}
		return res;
	}

	/*
	private void generaPrueba()
	{
		for(int x=0;x<width;x++){
			for(int y=0;y<height;y++){
				mapa[x][y]=0;
								
				
				if(y==0 || y==height-3){
					mapa[x][y]=2;					
				}
				
				if(y==1 || y==2 || y>height-3){
					mapa[x][y]=1;					
				}
				
				if((x==0 || x==width-1) && y<height-3){
					mapa[x][y]=2;										
				}
			}
		}		
	}*/
	
	public void update(GameContainer gameContainer, int deltaTime)
	{
		for(Entidad e: entidades){
			e.update(gameContainer, deltaTime, this);
		}
	}
	
	public void render(int xOff, int yOff) //, int capa)
	{
		map.render(-xOff, -yOff, 0);
		
		Collections.sort(entidades, new ComparadorZ());
		for(Entidad e : entidades){
			e.render(xOff, yOff);
		}
		
		map.render(-xOff, -yOff, 1);
		
		/*
		//Calcula la posicion de la casilla
		int xo=(xOff/TILE_SIZE);
		int yo=(yOff/TILE_SIZE);
		
		//Dibuja solo los que entran en la pantalla (para evitar que tire mucho y casque)
		for (int x = xo-1; x < xo+50; x++) {
			for (int y = yo-1; y < yo+30; y++) {
		
				//Si no se sale del mapa
				if(x>=0 && x<width && y<height && y>=0)
				{
					int valor=mapa[x][y];
					Image tile=tileSetSheet.getSprite(valor%TILESET_WIDTH, valor/TILESET_WIDTH);
					tile.draw((x*TILE_SIZE)- xOff, (y*TILE_SIZE)-yOff);
				}
			}
		}*/		
	}

	@Override
	public boolean blocked(PathFindingContext pathfinder, int tx, int ty) {
		return bloqueado[tx][ty];
	}

	@Override
	public float getCost(PathFindingContext pathfinder, int tx, int ty) {
		// TODO Auto-generated method stub
		return 1;
	}

	@Override
	public int getHeightInTiles() {		
		return map.getHeight();
	}

	@Override
	public int getWidthInTiles() {
		return map.getWidth();
	}

	@Override
	public void pathFinderVisited(int px, int py) {
		// TODO Auto-generated method stub
		
	}
}
